package com.qf.collection.homework;

import java.util.Collection;
import java.util.Iterator;

/**
 * 自定义集合，实现Collection接口，要求底层使用链表存放集合元素
 */
public class MyLinkedListCollection<E> implements Collection<E> {

    private Node<E> first;

    private int count;

    private Node<E> last;


    @Override
    public int size() {
        return count;
    }

    @Override
    public boolean isEmpty() {
        return count==0;
    }

    @Override
    public boolean contains(Object o) {

        Node<E> tmp = first;
        while (tmp!=null){
            if (tmp.data.equals(o)) {
                return true;
            }
            tmp=tmp.next;
        }

        return false;
    }

    @Override
    public Iterator<E> iterator() {

        return new Iterator<E>() {
            Node<E> index = first;

            @Override
            public boolean hasNext() {
                return index!=null;
            }

            @Override
            public E next() {
                E data = index.getData();
                index = index.getNext();
                return data;
            }
        };

    }

    @Override
    public Object[] toArray() {
        return new Object[0];
    }

    @Override
    public <T> T[] toArray(T[] a) {
        return null;
    }

    @Override
    public boolean add(E e) {
        //1. 创建Node对象
        Node<E> newNode = new Node<>(e);
        // 如果集合中已经有元素了
        if (last!=null){
            //2. 找到Node的插入位置 ，就是last
            Node index = last;
            //3. 插入Node，并且调整链表的结构
            index.setNext(newNode);
            last=newNode;
        }else {
            // 如果集合中没有元素
            first = newNode;
            last = newNode;
        }
        count++;
        return true;
    }

    @Override
    public boolean remove(Object o) {
        Node<E> tmp = first;
        Node<E> pre = null;  // 当前遍历节点的前置节点
        while (tmp!=null){
            if (tmp.getData().equals(o)){
                if (tmp == first){
                    // 如果首节点就是要删除的节点
                    first = tmp.next;
                    tmp.next = null;
                    count --;
                    if (first == null){  // 如果删除的节点恰好也是last
                        last = null;
                    }
                    return true;
                }else {
                    // 如果要删除的节点不是首节点
                    // 让pre节点的next指向 当前节点的next
                    pre.next = tmp.next;
                    tmp.next = null;
                    count--;
                    if (tmp == last){
                        last = pre;
                    }
                    return true;
                }

            }else {
                pre = tmp; // 记录当前节点的前一个节点
                tmp = tmp.next;  // 把当前节点向后移动
            }
        }
        return false;
    }

    @Override
    public boolean containsAll(Collection<?> c) {

        for (Object o : c) {
            if (!contains(o)) {
                return false;
            }
        }

        return true;
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        for (E e : c) {
            add(e);
        }
        return true;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return false;
    }

    @Override
    public void clear() {
        first = null;
        last = null;
        count = 0;
    }

    @Override
    public String toString() {

        StringBuffer stringBuffer = new StringBuffer("[ ");
        // 如何进行链表的遍历呢？
        Node<E> tmp = first;
        while (tmp!=null){
            stringBuffer.append(tmp.data.toString());
            stringBuffer.append(" ");
            // 注意：别忘记把tmp指向链表中的下一个元素
            tmp = tmp.next;
        }
        stringBuffer.append("]");
        return stringBuffer.toString();
    }
}
